﻿//typedef struct Stack {
//    int* a;
//    int top;
//    int capacity;
//}Stack;
//
//void StackInit(Stack* S) {
//    S->a = (int*)malloc(sizeof(int) * 4);
//    S->top = -1;
//    S->capacity = 4;
//}
//
//bool StackEmpty(Stack* S) {
//    return S->top == -1;
//}
//
//void StackPush(Stack* S, int x) {
//    if (S->top == S->capacity - 1) {
//        S->a = (int*)realloc(S->a, sizeof(int) * S->capacity * 2);
//        S->capacity *= 2;
//    }
//    S->a[++S->top] = x;
//}
//
//void StackPop(Stack* S) {
//    S->top--;
//}
//
//typedef struct {
//    Stack* SPush;
//    Stack* SPop;
//} MyQueue;
//
//
//MyQueue* myQueueCreate() {
//    MyQueue* Q = (MyQueue*)malloc(sizeof(MyQueue));
//    Q->SPush = (Stack*)malloc(sizeof(Stack));
//    StackInit(Q->SPush);
//    Q->SPop = (Stack*)malloc(sizeof(Stack));
//    StackInit(Q->SPop);
//    return Q;
//}
//
//void myQueuePush(MyQueue* obj, int x) {
//    StackPush(obj->SPush, x);
//}
//
//int myQueuePop(MyQueue* obj) {
//    if (StackEmpty(obj->SPop)) {
//        while (!StackEmpty(obj->SPush)) {
//            StackPush(obj->SPop, obj->SPush->a[obj->SPush->top]);
//            StackPop(obj->SPush);
//        }
//    }
//    int x = obj->SPop->a[obj->SPop->top];
//    StackPop(obj->SPop);
//    return x;
//}
//
//int myQueuePeek(MyQueue* obj) {
//    if (StackEmpty(obj->SPop)) {
//        while (!StackEmpty(obj->SPush)) {
//            StackPush(obj->SPop, obj->SPush->a[obj->SPush->top]);
//            StackPop(obj->SPush);
//        }
//    }
//    int x = obj->SPop->a[obj->SPop->top];
//    return x;
//}
//
//bool myQueueEmpty(MyQueue* obj) {
//    return StackEmpty(obj->SPush) && StackEmpty(obj->SPop);
//}
//
//void myQueueFree(MyQueue* obj) {
//    free(obj->SPush->a);
//    free(obj->SPop->a);
//    free(obj->SPush);
//    free(obj->SPop);
//    free(obj);
//}

//typedef struct Node {
//    int val;
//    struct Node* next;
//}Node;
//
//typedef struct {
//    Node* front;
//    Node* tail;
//    int size;
//    int k;
//} MyCircularQueue;
//
//MyCircularQueue* myCircularQueueCreate(int k) {
//    MyCircularQueue* Queue = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
//    Queue->front = Queue->tail = 0;
//    Queue->size = 0;
//    Queue->k = k;
//    return Queue;
//}
//
//bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
//    if (obj->size == obj->k) {
//        return false;
//    }
//    Node* node = (Node*)malloc(sizeof(Node));
//    node->val = value;
//    if (!obj->size) {
//        obj->front = obj->tail = node;
//    }
//    else {
//        obj->tail->next = node;
//        obj->tail = node;
//    }
//    obj->tail->next = obj->front;
//    obj->size++;
//    return true;
//}
//
//bool myCircularQueueDeQueue(MyCircularQueue* obj) {
//    if (!obj->size) {
//        return false;
//    }
//    Node* next = obj->front->next;
//    free(obj->front);
//    if (obj->size == 1) {
//        obj->size--;
//        return true;
//    }
//    obj->front = next;
//    obj->tail->next = obj->front;
//    obj->size--;
//    return true;
//}
//
//int myCircularQueueFront(MyCircularQueue* obj) {
//    if (!obj->size) {
//        return -1;
//    }
//    return obj->front->val;
//}
//
//int myCircularQueueRear(MyCircularQueue* obj) {
//    if (!obj->size) {
//        return -1;
//    }
//    return obj->tail->val;
//}
//
//bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
//    return obj->size == 0;
//}
//
//bool myCircularQueueIsFull(MyCircularQueue* obj) {
//    return obj->size == obj->k;
//}
//
//void myCircularQueueFree(MyCircularQueue* obj) {
//    while (obj->size--) {
//        Node* node = obj->front->next;
//        free(obj->front);
//        obj->front = node;
//    }
//    free(obj);
//}